JavaScript'ning Shaxsiy Maydonlari: Haqiqiy Klass Inkapsulyatsiyasi va Ma'lumotlarni Yashirish bo'yicha Chuqur Tahlil

Dasturiy ta'minotni ishlab chiqish dunyosida mustahkam, qo'llab-quvvatlanadigan va xavfsiz ilovalarni yaratish eng muhim vazifadir. Bu maqsadga erishishning asosiy tamoyillaridan biri, ayniqsa Obyektga Yo'naltirilgan Dasturlashda (OYD), inkapsulyatsiya prinsipidir. Inkapsulyatsiya - bu ma'lumotlarni (xususiyatlarni) ushbu ma'lumotlar ustida ishlaydigan metodlar bilan birlashtirish va obyektning ichki holatiga to'g'ridan-to'g'ri kirishni cheklashdir. Ko'p yillar davomida JavaScript dasturchilari haqiqiy shaxsiy klass a'zolarini yaratishning til darajasida qo'llab-quvvatlanadigan usulini orzu qilishgan. Garchi kelishuvlar va na'munalar vaqtinchalik yechimlarni taklif qilgan bo'lsa-da, ular hech qachon to'liq ishonchli bo'lmagan.

Bu davr tugadi. ECMAScript 2022 spetsifikatsiyasiga shaxsiy klass maydonlarining rasman kiritilishi bilan JavaScript endi haqiqiy ma'lumotlarni yashirish uchun oddiy va kuchli sintaksisni taqdim etadi. Xesh belgisi (#) bilan belgilanadigan bu xususiyat, bizning klasslarimizni loyihalash va tuzish uslubimizni tubdan o'zgartiradi va JavaScript'ning OYD imkoniyatlarini Java, C# yoki Python kabi tillarga yanada yaqinlashtiradi.

Ushbu keng qamrovli qo'llanma sizni JavaScript'ning shaxsiy maydonlari bo'yicha chuqur tahlilga olib boradi. Biz ularning zaruriyati ortidagi "nima uchun"ni o'rganamiz, shaxsiy maydonlar va metodlar uchun sintaksisni tahlil qilamiz, ularning asosiy afzalliklarini ochib beramiz va amaliy, real hayotiy stsenariylar bilan tanishib chiqamiz. Tajribali dasturchi bo'lasizmi yoki JavaScript klasslari bilan endigina tanishayotgan bo'lsangiz ham, ushbu zamonaviy xususiyatni tushunish professional darajadagi kod yozish uchun juda muhimdir.

Eski Usul: JavaScript'da Shaxsiylikni Simulyatsiya Qilish

# sintaksisining ahamiyatini to'liq tushunish uchun JavaScript dasturchilari shaxsiylikka erishishga qanday harakat qilganliklari tarixini tushunish muhimdir. Bu usullar aqlli bo'lgan, ammo pirovardida haqiqiy, majburiy inkapsulyatsiyani ta'minlay olmagan.

Pastki Chiziq Kelishuvi (_)

Eng keng tarqalgan va uzoq vaqtdan beri mavjud bo'lgan yondashuv nomlash kelishuvi edi: xususiyat yoki metod nomidan oldin pastki chiziq qo'yish. Bu boshqa dasturchilarga signal bo'lib xizmat qilardi: "Bu ichki xususiyat. Iltimos, unga to'g'ridan-to'g'ri tegmang."

Oddiy `BankAccount` klassini ko'rib chiqaylik:

            
class BankAccount {
  constructor(ownerName, initialBalance) {
    this.ownerName = ownerName;
    this._balance = initialBalance; // Kelishuv: Bu 'shaxsiy'
  }

  deposit(amount) {
    if (amount > 0) {
      this._balance += amount;
      console.log(`Depozit qilindi: ${amount}. Yangi balans: ${this._balance}`);
    }
  }

  // Balansga xavfsiz kirish uchun ommaviy getter
  getBalance() {
    return this._balance;
  }
}

const myAccount = new BankAccount('John Doe', 1000);
console.log(myAccount.getBalance()); // 1000

// Muammo: Kelishuvga e'tibor bermaslik mumkin
myAccount._balance = -5000; // To'g'ridan-to'g'ri o'zgartirish mumkin!
console.log(myAccount.getBalance()); // -5000 (Noto'g'ri holat!)

            

              
                Copy
              
            
          

Asosiy zaiflik aniq: pastki chiziq faqatgina bir taklif. Tashqi kodning `_balance` ga kirishini yoki uni o'zgartirishini oldini oladigan til darajasidagi mexanizm mavjud emas, bu esa obyekt holatini buzishi va `deposit` kabi metodlar ichidagi har qanday validatsiya mantiqini chetlab o'tishi mumkin.

Qamrovlar (Closures) va Modul Na'munasi

Yanada mustahkamroq usul qamrovlardan (closures) foydalanib shaxsiy holat yaratishni o'z ichiga olgan. `class` sintaksisi kiritilishidan oldin, bu ko'pincha fabrika funksiyalari va modul na'munasi yordamida amalga oshirilardi.

            
function createBankAccount(ownerName, initialBalance) {
  let balance = initialBalance; // Bu o'zgaruvchi qamrov (closure) tufayli shaxsiydir

  return {
    getOwner: () => ownerName,

    getBalance: () => balance, // Balans qiymatini ommaviy ravishda ochib beradi

    deposit: function(amount) {
      if (amount > 0) {
        balance += amount;
        console.log(`Depozit qilindi: ${amount}. Yangi balans: ${balance}`);
      }
    },

    withdraw: function(amount) {
      if (amount > 0 && amount <= balance) {
        balance -= amount;
        console.log(`Yechib olindi: ${amount}. Yangi balans: ${balance}`);
      } else {
        console.log('Mablag'' yetarli emas yoki noto''g''ri miqdor.');
      }
    }
  };
}

const myAccount = createBankAccount('Jane Smith', 2000);

console.log(myAccount.getBalance()); // 2000
myAccount.deposit(500); // Depozit qilindi: 500. Yangi balans: 2500

// Shaxsiy o'zgaruvchiga kirishga urinish muvaffaqiyatsiz tugaydi
console.log(myAccount.balance); // undefined
myAccount.balance = 9999; // Yangi, aloqador bo'lmagan xususiyat yaratadi
console.log(myAccount.getBalance()); // 2500 (Ichki holat xavfsiz!)

            

              
                Copy
              
            
          

Bu na'muna haqiqiy shaxsiylikni ta'minlaydi. `balance` o'zgaruvchisi faqat `createBankAccount` funksiyasi doirasida mavjud va tashqaridan unga kirish imkoni yo'q. Biroq, bu yondashuvning o'z kamchiliklari bor: u ko'proq so'zli bo'lishi, xotira samaradorligi pastroq bo'lishi (har bir nusxa metodlarning o'z nusxasiga ega bo'ladi) va zamonaviy `class` sintaksisi va uning merosxo'rlik kabi xususiyatlari bilan unchalik yaxshi integratsiyalashmaydi.

Haqiqiy Shaxsiylikni Taqdim Etish: Xesh # Sintaksisi

Xesh (#) prefiksi bilan shaxsiy klass maydonlarining kiritilishi bu muammolarni oqlangan tarzda hal qiladi. U qamrovlarning (closures) kuchli shaxsiyligini klasslarning toza, tanish sintaksisi bilan ta'minlaydi. Bu kelishuv emas; bu qat'iy, til darajasida majburiy qoidadir.

Shaxsiy maydon klass tanasining yuqori darajasida e'lon qilinishi kerak. Klass tashqarisidan shaxsiy maydonga kirishga urinish kompilyatsiya vaqtida SyntaxError yoki ish vaqtida TypeError ga olib keladi, bu esa shaxsiylik chegarasini buzishni imkonsiz qiladi.

Asosiy Sintaksis: Shaxsiy Instansiya Maydonlari

Keling, `BankAccount` klassimizni shaxsiy maydon yordamida qayta ishlaymiz.

            
class BankAccount {
  // 1. Shaxsiy maydonni e'lon qilish
  #balance;

  constructor(ownerName, initialBalance) {
    this.ownerName = ownerName; // Ommaviy maydon
    // 2. Shaxsiy maydonni ishga tushirish
    if (initialBalance > 0) {
      this.#balance = initialBalance;
    } else {
      throw new Error('Boshlang''ich balans musbat bo''lishi kerak.');
    }
  }

  deposit(amount) {
    if (amount > 0) {
      this.#balance += amount;
      console.log(`Depozit qilindi: ${amount}.`);
    }
  }

  withdraw(amount) {
    if (amount > 0 && amount <= this.#balance) {
      this.#balance -= amount;
      console.log(`Yechib olindi: ${amount}.`);
    } else {
      console.error('Yechib olish muvaffaqiyatsiz: Noto''g''ri miqdor yoki mablag'' yetarli emas.');
    }
  }

  getBalance() {
    // Ommaviy metod shaxsiy maydonga nazoratli kirishni ta'minlaydi
    return this.#balance;
  }
}

const myAccount = new BankAccount('Alice', 500);
myAccount.deposit(100);
console.log(myAccount.getBalance()); // 600

// Endi, keling, uni buzishga harakat qilamiz...

try {
  // Bu muvaffaqiyatsiz tugaydi. Bu taklif emas; bu qat'iy qoida.
  console.log(myAccount.#balance);
} catch (e) {
  console.error(e); // TypeError: #balance shaxsiy a'zosini uni e'lon qilmagan klass obyektidan o'qib bo'lmaydi
}

// Bu shaxsiy maydonni o'zgartirmaydi. Bu yangi, ommaviy xususiyat yaratadi.
myAccount['#balance'] = 9999;
console.log(myAccount.getBalance()); // 600 (Ichki holat xavfsizligicha qoladi!)

            

              
                Copy
              
            
          

Bu inqilobiy o'zgarish. #balance maydoni haqiqatan ham shaxsiydir. Unga faqat `BankAccount` klassi tanasi ichida yozilgan kod orqali kirish yoki uni o'zgartirish mumkin. Endi obyektimizning yaxlitligi JavaScript dvigatelining o'zi tomonidan himoyalangan.

Shaxsiy Metodlar

Xuddi shu # sintaksisi metodlarga ham tegishli. Bu klassning implementatsiyasining bir qismi bo'lgan, ammo uning ommaviy API'si sifatida ko'rsatilmasligi kerak bo'lgan ichki yordamchi funksiyalar uchun juda foydalidir.

Tasavvur qiling, `ReportGenerator` klassi yakuniy hisobotni yaratishdan oldin ba'zi murakkab ichki hisob-kitoblarni amalga oshirishi kerak.

            
class ReportGenerator {
  #data;

  constructor(rawData) {
    this.#data = rawData;
  }

  // Ichki hisob-kitoblar uchun shaxsiy yordamchi metod
  #calculateTotalSales() {
    console.log('Murakkab va maxfiy hisob-kitoblar bajarilmoqda...');
    return this.#data.reduce((total, item) => total + item.price * item.quantity, 0);
  }

  // Formatlash uchun shaxsiy yordamchi
  #formatCurrency(amount) {
    // Real hayotda bu global auditoriya uchun Intl.NumberFormat'dan foydalanardi
    return `$${amount.toFixed(2)}`;
  }

  // Ommaviy API metodi
  generateSalesReport() {
    const totalSales = this.#calculateTotalSales(); // Shaxsiy metodni chaqiradi
    const formattedTotal = this.#formatCurrency(totalSales); // Boshqa shaxsiy metodni chaqiradi

    return {
      reportDate: new Date(),
      totalSales: formattedTotal,
      itemCount: this.#data.length
    };
  }
}

const salesData = [
  { price: 10, quantity: 5 },
  { price: 25, quantity: 2 },
  { price: 5, quantity: 20 }
];

const generator = new ReportGenerator(salesData);
const report = generator.generateSalesReport();
console.log(report); // { reportDate: ..., totalSales: '$200.00', itemCount: 3 }

// Tashqaridan shaxsiy metodni chaqirishga urinish muvaffaqiyatsiz tugaydi
try {
  generator.#calculateTotalSales();
} catch (e) {
  console.error(e.name, e.message);
}

            

              
                Copy
              
            
          

#calculateTotalSales va #formatCurrency ni shaxsiy qilib, biz kelajakda `ReportGenerator` klassidan foydalanadigan kodni buzishdan xavotirlanmasdan ularning implementatsiyasini o'zgartirishimiz, nomini o'zgartirishimiz yoki hatto olib tashlashimiz mumkin. Ommaviy shartnoma faqat `generateSalesReport` metodi bilan belgilanadi.

Shaxsiy Statik Maydonlar va Metodlar

`static` kalit so'zi `private` sintaksisi bilan birlashtirilishi mumkin. Shaxsiy statik a'zolar klassning biron bir nusxasiga emas, balki klassning o'ziga tegishli.

Bu barcha nusxalar o'rtasida umumiy bo'lishi kerak bo'lgan, ammo ommaviy doiradan yashirin qolishi kerak bo'lgan ma'lumotlarni saqlash uchun foydalidir. Klassik misol - klassning nechta nusxasi yaratilganligini kuzatib borish uchun hisoblagich.

            
class DatabaseConnection {
  // Nusxalarni sanash uchun shaxsiy statik maydon
  static #instanceCount = 0;

  // Ichki hodisalarni qayd etish uchun shaxsiy statik metod
  static #log(message) {
    console.log(`[DBConnection Internal]: ${message}`);
  }

  constructor(connectionString) {
    this.connectionString = connectionString;
    DatabaseConnection.#instanceCount++;
    DatabaseConnection.#log(`Yangi ulanish yaratildi. Jami: ${DatabaseConnection.#instanceCount}`);
  }

  connect() {
    console.log(`${this.connectionString} ga ulanilmoqda...`);
  }

  // Sanoqni olish uchun ommaviy statik metod
  static getInstanceCount() {
    return DatabaseConnection.#instanceCount;
  }
}

const conn1 = new DatabaseConnection('server1/db');
const conn2 = new DatabaseConnection('server2/db');

console.log(`Jami yaratilgan ulanishlar: ${DatabaseConnection.getInstanceCount()}`); // Jami yaratilgan ulanishlar: 2

// Tashqaridan shaxsiy statik a'zolarga kirish imkonsiz
console.log(DatabaseConnection.#instanceCount); // SyntaxError
DatabaseConnection.#log('Trying to log'); // SyntaxError

            

              
                Copy
              
            
          

Nima uchun Shaxsiy Maydonlardan Foydalanish Kerak? Asosiy Afzalliklar

Sintaksisni ko'rib chiqqanimizdan so'ng, keling, nima uchun bu xususiyat zamonaviy dasturiy ta'minotni ishlab chiqish uchun bunchalik muhim ekanligini tushunishimizni mustahkamlaymiz.

1. Haqiqiy Inkapsulyatsiya va Ma'lumotlarni Yashirish

Bu asosiy afzallikdir. Shaxsiy maydonlar klassning ichki implementatsiyasi va uning ommaviy interfeysi o'rtasidagi chegarani majburiy qiladi. Obyektning holatini faqat uning ommaviy metodlari orqali o'zgartirish mumkin, bu esa obyektning har doim to'g'ri va izchil holatda bo'lishini ta'minlaydi. Bu tashqi kodning obyektning ichki ma'lumotlariga o'zboshimchalik bilan, tekshirilmagan o'zgartirishlar kiritishini oldini oladi.

2. Mustahkam va Barqaror API'larni Yaratish

Siz klass yoki modulni boshqalar foydalanishi uchun ochganingizda, siz shartnoma yoki API'ni belgilaysiz. Ichki xususiyatlar va metodlarni shaxsiy qilib, siz klassingizning qaysi qismlari iste'molchilar uchun ishonchli ekanligini aniq ko'rsatasiz. Bu sizga, muallifga, keyinchalik klassingizdan foydalanadigan har bir kishining kodini buzmasdan ichki implementatsiyani qayta ishlash, optimallashtirish yoki butunlay o'zgartirish erkinligini beradi. Agar hamma narsa ommaviy bo'lsa, har qanday o'zgarish buzuvchi o'zgarish bo'lishi mumkin edi.

3. Tasodifiy O'zgartirishlarning Oldini Olish va Invariantlarni Ta'minlash

Ommaviy metodlar (getterlar va setterlar) bilan birlashtirilgan shaxsiy maydonlar sizga validatsiya mantiqini qo'shish imkonini beradi. Obyekt o'zining qoidalarini yoki 'invariantlarini' - har doim to'g'ri bo'lishi kerak bo'lgan shartlarni majburiy qila oladi.

            
class Circle {
  #radius;

  constructor(radius) {
    this.setRadius(radius);
  }

  // Validatsiyali ommaviy setter
  setRadius(newRadius) {
    if (typeof newRadius !== 'number' || newRadius <= 0) {
      throw new Error('Radius musbat son bo''lishi kerak.');
    }
    this.#radius = newRadius;
  }

  get radius() {
    return this.#radius;
  }

  get area() {
    return Math.PI * this.#radius * this.#radius;
  }
}

const c = new Circle(10);
console.log(c.area); // ~314.159

c.setRadius(20); // Kutilganidek ishlaydi
console.log(c.radius); // 20

try {
  c.setRadius(-5); // Validatsiya tufayli muvaffaqiyatsiz
} catch (e) {
  console.error(e.message); // 'Radius musbat son bo''lishi kerak.'
}

// Ichki #radius hech qachon noto'g'ri holatga o'rnatilmaydi.
console.log(c.radius); // 20

            

              
                Copy
              
            
          

4. Yaxshilangan Kod Aniqligi va Qo'llab-quvvatlanuvchanligi

# sintaksisi aniq. Boshqa bir dasturchi sizning klassingizni o'qiyotganda, uning mo'ljallangan ishlatilishi haqida hech qanday noaniqlik bo'lmaydi. Ular darhol qaysi qismlar ichki foydalanish uchun va qaysilari ommaviy API'ning bir qismi ekanligini bilib oladilar. Bu o'z-o'zini hujjatlashtiruvchi tabiati kodni vaqt o'tishi bilan tushunish, muhokama qilish va qo'llab-quvvatlashni osonlashtiradi.

Amaliy Stsenariylar va Ilg'or Na'munalar

Keling, butun dunyo bo'ylab dasturchilar har kuni duch keladigan murakkabroq, real hayotiy stsenariylarda shaxsiy maydonlar qanday qo'llanilishini ko'rib chiqamiz.

1-Stsenariy: Xavfsiz `User` Klassi

Foydalanuvchi ma'lumotlari bilan ishlaydigan har qanday ilovada xavfsizlik eng muhim ustuvorlikdir. Siz hech qachon parol xeshi yoki shaxsiy identifikatsiya raqami kabi maxfiy ma'lumotlarning foydalanuvchi obyektida ommaviy ravishda mavjud bo'lishini xohlamaysiz.

            
import { hash, compare } from 'some-bcrypt-library'; // To'qima kutubxona

class User {
  #passwordHash;
  #personalIdentifier;
  #lastLoginTimestamp;

  constructor(username, password, pii) {
    this.username = username; // Ommaviy foydalanuvchi nomi
    this.#passwordHash = hash(password); // Faqat xeshni saqlang va uni shaxsiy tuting
    this.#personalIdentifier = pii;
    this.#lastLoginTimestamp = null;
  }

  async authenticate(passwordAttempt) {
    const isMatch = await compare(passwordAttempt, this.#passwordHash);
    if (isMatch) {
      this.#lastLoginTimestamp = Date.now();
      console.log('Autentifikatsiya muvaffaqiyatli.');
      return true;
    }
    console.log('Autentifikatsiya muvaffaqiyatsiz.');
    return false;
  }

  // Maxfiy bo'lmagan ma'lumotlarni olish uchun ommaviy metod
  getProfileData() {
    return {
      username: this.username,
      lastLogin: this.#lastLoginTimestamp ? new Date(this.#lastLoginTimestamp) : 'Hech qachon'
    };
  }

  // passwordHash yoki personalIdentifier uchun getter yo'q!
}

const user = new User('globaldev', 'superS3cret!', 'ID-12345');

// Maxfiy ma'lumotlarga tashqaridan kirish mutlaqo imkonsiz.
console.log(user.username); // 'globaldev'
console.log(user.#passwordHash); // SyntaxError!

            

              
                Copy
              
            
          

2-Stsenariy: UI Komponentida Ichki Holatni Boshqarish

Tasavvur qiling, siz qayta ishlatiladigan UI komponentini, masalan, rasm karuselini yaratyapsiz. Komponent o'zining ichki holatini, masalan, hozirgi faol slayd indeksini kuzatib borishi kerak. Bu holat faqat komponentning ommaviy metodlari (`next()`, `prev()`, `goToSlide()`) orqali boshqarilishi kerak.

            
class Carousel {
  #slides;
  #currentIndex;
  #containerElement;

  constructor(containerSelector, slidesData) {
    this.#containerElement = document.querySelector(containerSelector);
    this.#slides = slidesData;
    this.#currentIndex = 0;
    this.#render();
  }

  // Barcha DOM yangilanishlarini boshqarish uchun shaxsiy metod
  #render() {
    const currentSlide = this.#slides[this.#currentIndex];
    // Joriy slaydni ko'rsatish uchun DOM'ni yangilash mantiqi...
    console.log(`Slayd ${this.#currentIndex + 1} ko'rsatilmoqda: ${currentSlide.title}`);
  }

  // Ommaviy API metodlari
  next() {
    this.#currentIndex = (this.#currentIndex + 1) % this.#slides.length;
    this.#render();
  }

  prev() {
    this.#currentIndex = (this.#currentIndex - 1 + this.#slides.length) % this.#slides.length;
    this.#render();
  }

  getCurrentSlide() {
    return this.#slides[this.#currentIndex];
  }
}

const myCarousel = new Carousel('#carousel-widget', [
  { title: 'Tokyo Skyline', image: 'tokyo.jpg' },
  { title: 'Paris at Night', image: 'paris.jpg' },
  { title: 'New York Central Park', image: 'nyc.jpg' }
]);

myCarousel.next(); // Slayd 2 ni ko'rsatadi
myCarousel.next(); // Slayd 3 ni ko'rsatadi

// Siz komponent holatini tashqaridan buza olmaysiz.
// myCarousel.#currentIndex = 10; // SyntaxError! Bu komponent yaxlitligini himoya qiladi.

            

              
                Copy
              
            
          

Umumiy Qiyinchiliklar va Muhim Mulohazalar

Kuchli bo'lishiga qaramay, shaxsiy maydonlar bilan ishlaganda e'tiborga olish kerak bo'lgan bir nechta nozikliklar mavjud.

1. Shaxsiy Maydonlar Faqat Xususiyatlar Emas, Balki Sintaksisdir

Muhim farq shundaki, bir shaxsiy maydon `this.#field` `this['#field']` satr xususiyati bilan bir xil emas. Siz shaxsiy maydonlarga dinamik qavs belgisi yordamida kira olmaysiz. Ularning nomlari yozish vaqtida belgilanadi.

            
class MyClass {
  #privateField = 42;

  getPrivateFieldValue() {
    return this.#privateField; // OK
  }

  getPrivateFieldDynamically(fieldName) {
    // return this[fieldName]; // Bu shaxsiy maydonlar uchun ishlamaydi
  }
}

const instance = new MyClass();
console.log(instance.getPrivateFieldValue()); // 42
// console.log(instance['#privateField']); // undefined

            

              
                Copy
              
            
          

2. Oddiy Obyektlarda Shaxsiy Maydonlar Yo'q

Bu xususiyat faqat `class` sintaksisiga xosdir. Siz obyekt literali sintaksisi bilan yaratilgan oddiy JavaScript obyektlarida shaxsiy maydonlar yarata olmaysiz.

3. Merosxo'rlik va Shaxsiy Maydonlar

Bu ularning dizaynining asosiy jihatidir: voris klass ota klassining shaxsiy maydonlariga kira olmaydi. Bu juda kuchli inkapsulyatsiyani ta'minlaydi. Voris klass ota klassning ichki holati bilan faqat ota klassning ommaviy yoki himoyalangan metodlari orqali muloqot qila oladi (JavaScript'da `protected` kalit so'zi yo'q, lekin buni kelishuvlar bilan simulyatsiya qilish mumkin).

            
class Vehicle {
  #fuel;

  constructor(initialFuel) {
    this.#fuel = initialFuel;
  }

  drive(kilometers) {
    const fuelNeeded = kilometers / 10; // Oddiy iste'mol modeli
    if (this.#fuel >= fuelNeeded) {
      this.#fuel -= fuelNeeded;
      console.log(`${kilometers} km yurildi.`);
      return true;
    }
    console.log('Yoqilg''i yetarli emas.');
    return false;
  }
}

class Car extends Vehicle {
  constructor(initialFuel) {
    super(initialFuel);
  }

  checkFuel() {
    // Bu xatolikka olib keladi!
    // Avtomobil (Car) Vehicle'ning #fuel'iga to'g'ridan-to'g'ri kira olmaydi.
    // console.log(this.#fuel);
    // Buni ishlatish uchun Vehicle klassi ommaviy `getFuel()` metodini taqdim etishi kerak edi.
  }
}

const myCar = new Car(50);
myCar.drive(100); // 100 km yurildi.
// myCar.checkFuel(); // SyntaxError'ga sabab bo'lardi

            

              
                Copy
              
            
          

4. Nosozliklarni Tuzatish va Sinovdan O'tkazish

Haqiqiy shaxsiylik shuni anglatadiki, siz shaxsiy maydon qiymatini brauzerning ishlab chiquvchilar konsolidan yoki Node.js nosozliklarni tuzatuvchisidan shunchaki `instance.#field` deb yozib, osonlikcha tekshira olmaysiz. Bu kutilgan xatti-harakat bo'lsa-da, nosozliklarni tuzatishni biroz qiyinlashtirishi mumkin. Buni yumshatish strategiyalari quyidagilarni o'z ichiga oladi:

• Shaxsiy maydonlar ko'rinadigan klass metodlari ichida to'xtash nuqtalaridan (breakpoints) foydalanish.
• Ishlab chiqish jarayonida tekshirish uchun vaqtincha ommaviy getter metodini (masalan, `_debug_getInternalState()`) qo'shish.
• Obyektning xatti-harakatini uning ommaviy API'si orqali tekshiradigan keng qamrovli birlik testlarini yozish, bunda kuzatiladigan natijalarga asoslanib ichki holat to'g'ri bo'lishi kerakligini tasdiqlash.

Global Perspektiva: Brauzer va Muhit Qo'llab-quvvatlashi

Shaxsiy klass maydonlari zamonaviy JavaScript xususiyati bo'lib, ECMAScript 2022 da rasman standartlashtirilgan. Bu shuni anglatadiki, ular barcha asosiy zamonaviy brauzerlarda (Chrome, Firefox, Safari, Edge) va Node.js ning so'nggi versiyalarida (shaxsiy metodlar uchun v14.6.0+, shaxsiy maydonlar uchun v12.0.0+) qo'llab-quvvatlanadi.

Eski brauzerlar yoki muhitlarni qo'llab-quvvatlashi kerak bo'lgan loyihalar uchun sizga Babel kabi transpilyator kerak bo'ladi. `@babel/plugin-proposal-class-properties` va `@babel/plugin-proposal-private-methods` plaginlaridan foydalanib, Babel zamonaviy `#` sintaksisini shaxsiylikni simulyatsiya qilish uchun `WeakMap`lardan foydalanadigan eski, mos keluvchi JavaScript kodiga aylantiradi, bu esa sizga orqaga qarab moslikni yo'qotmasdan bugungi kunda bu xususiyatdan foydalanish imkonini beradi.

Loyihangizning qo'llab-quvvatlash talablariga javob berishini ta'minlash uchun har doim Can I Use... yoki MDN Web Docs kabi manbalardagi yangilangan moslik jadvallarini tekshiring.

Xulosa: Yaxshiroq Kod Uchun Zamonaviy JavaScript'ni Qabul Qilish

JavaScript'ning shaxsiy maydonlari shunchaki sintaktik qulaylikdan ko'ra ko'proq narsadir; ular til evolyutsiyasida muhim qadamni anglatadi va dasturchilarga xavfsizroq, tuzilmaliroq va professionalroq obyektga yo'naltirilgan kod yozish imkonini beradi. Haqiqiy inkapsulyatsiya uchun mahalliy mexanizmni taqdim etish orqali # sintaksisi eski kelishuvlarning noaniqligini va qamrovlarga asoslangan na'munalarning murakkabligini yo'q qiladi.

Asosiy xulosalar aniq:

• Haqiqiy Shaxsiylik: # prefiksi klass tashqarisidan kirib bo'lmaydigan, haqiqatan ham shaxsiy bo'lgan va JavaScript dvigateli tomonidan majburiy qilingan klass a'zolarini yaratadi.
• Mustahkam API'lar: Inkapsulyatsiya sizga ichki implementatsiya tafsilotlarini o'zgartirish moslashuvchanligini saqlab qolgan holda barqaror ommaviy interfeyslarni yaratish imkonini beradi.
• Yaxshilangan Kod Yaxlitligi: Obyekt holatiga kirishni nazorat qilish orqali siz noto'g'ri yoki tasodifiy o'zgartirishlarning oldini olasiz, bu esa kamroq xatoliklarga olib keladi.
• Yaxshilangan Aniqlik: Sintaksis sizning maqsadingizni aniq e'lon qiladi, bu esa global jamoangiz a'zolari uchun klasslarni tushunish va qo'llab-quvvatlashni osonlashtiradi.

Keyingi JavaScript loyihangizni boshlayotganingizda yoki mavjudini qayta ishlayotganingizda, shaxsiy maydonlarni kiritishga ongli ravishda harakat qiling. Bu sizning dasturchi asboblar to'plamingizdagi kuchli vosita bo'lib, sizga global auditoriya uchun xavfsizroq, qo'llab-quvvatlanadigan va pirovardida muvaffaqiyatliroq ilovalar yaratishga yordam beradi.